home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / swap.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  9KB  |  294 lines
  1. #ifndef _LINUX_SWAP_H
  2. #define _LINUX_SWAP_H
  3.  
  4. #include <linux/config.h>
  5. #include <linux/spinlock.h>
  6. #include <linux/linkage.h>
  7. #include <linux/mmzone.h>
  8. #include <linux/list.h>
  9. #include <linux/sched.h>
  10. #include <asm/atomic.h>
  11. #include <asm/page.h>
  12.  
  13. #define SWAP_FLAG_PREFER    0x8000    /* set if swap priority specified */
  14. #define SWAP_FLAG_PRIO_MASK    0x7fff
  15. #define SWAP_FLAG_PRIO_SHIFT    0
  16.  
  17. static inline int current_is_kswapd(void)
  18. {
  19.     return current->flags & PF_KSWAPD;
  20. }
  21.  
  22. /*
  23.  * MAX_SWAPFILES defines the maximum number of swaptypes: things which can
  24.  * be swapped to.  The swap type and the offset into that swap type are
  25.  * encoded into pte's and into pgoff_t's in the swapcache.  Using five bits
  26.  * for the type means that the maximum number of swapcache pages is 27 bits
  27.  * on 32-bit-pgoff_t architectures.  And that assumes that the architecture packs
  28.  * the type/offset into the pte as 5/27 as well.
  29.  */
  30. #define MAX_SWAPFILES_SHIFT    5
  31. #define MAX_SWAPFILES        (1 << MAX_SWAPFILES_SHIFT)
  32.  
  33. /*
  34.  * Magic header for a swap area. The first part of the union is
  35.  * what the swap magic looks like for the old (limited to 128MB)
  36.  * swap area format, the second part of the union adds - in the
  37.  * old reserved area - some extra information. Note that the first
  38.  * kilobyte is reserved for boot loader or disk label stuff...
  39.  *
  40.  * Having the magic at the end of the PAGE_SIZE makes detecting swap
  41.  * areas somewhat tricky on machines that support multiple page sizes.
  42.  * For 2.5 we'll probably want to move the magic to just beyond the
  43.  * bootbits...
  44.  */
  45. union swap_header {
  46.     struct {
  47.         char reserved[PAGE_SIZE - 10];
  48.         char magic[10];            /* SWAP-SPACE or SWAPSPACE2 */
  49.     } magic;
  50.     struct {
  51.         char         bootbits[1024];    /* Space for disklabel etc. */
  52.         unsigned int version;
  53.         unsigned int last_page;
  54.         unsigned int nr_badpages;
  55.         unsigned int padding[125];
  56.         unsigned int badpages[1];
  57.     } info;
  58. };
  59.  
  60.  /* A swap entry has to fit into a "unsigned long", as
  61.   * the entry is hidden in the "index" field of the
  62.   * swapper address space.
  63.   */
  64. typedef struct {
  65.     unsigned long val;
  66. } swp_entry_t;
  67.  
  68. /*
  69.  * current->reclaim_state points to one of these when a task is running
  70.  * memory reclaim
  71.  */
  72. struct reclaim_state {
  73.     unsigned long reclaimed_slab;
  74. };
  75.  
  76. #ifdef __KERNEL__
  77.  
  78. struct address_space;
  79. struct sysinfo;
  80. struct writeback_control;
  81. struct zone;
  82.  
  83. /*
  84.  * A swap extent maps a range of a swapfile's PAGE_SIZE pages onto a range of
  85.  * disk blocks.  A list of swap extents maps the entire swapfile.  (Where the
  86.  * term `swapfile' refers to either a blockdevice or an IS_REG file.  Apart
  87.  * from setup, they're handled identically.
  88.  *
  89.  * We always assume that blocks are of size PAGE_SIZE.
  90.  */
  91. struct swap_extent {
  92.     struct list_head list;
  93.     pgoff_t start_page;
  94.     pgoff_t nr_pages;
  95.     sector_t start_block;
  96. };
  97.  
  98. /*
  99.  * Max bad pages in the new format..
  100.  */
  101. #define __swapoffset(x) ((unsigned long)&((union swap_header *)0)->x)
  102. #define MAX_SWAP_BADPAGES \
  103.     ((__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int))
  104.  
  105. enum {
  106.     SWP_USED    = (1 << 0),    /* is slot in swap_info[] used? */
  107.     SWP_WRITEOK    = (1 << 1),    /* ok to write to this swap?    */
  108.     SWP_ACTIVE    = (SWP_USED | SWP_WRITEOK),
  109. };
  110.  
  111. #define SWAP_CLUSTER_MAX 32
  112.  
  113. #define SWAP_MAP_MAX    0x7fff
  114. #define SWAP_MAP_BAD    0x8000
  115.  
  116. /*
  117.  * The in-memory structure used to track swap areas.
  118.  * extent_list.prev points at the lowest-index extent.  That list is
  119.  * sorted.
  120.  */
  121. struct swap_info_struct {
  122.     unsigned int flags;
  123.     spinlock_t sdev_lock;
  124.     struct file *swap_file;
  125.     struct block_device *bdev;
  126.     struct list_head extent_list;
  127.     int nr_extents;
  128.     struct swap_extent *curr_swap_extent;
  129.     unsigned old_block_size;
  130.     unsigned short * swap_map;
  131.     unsigned int lowest_bit;
  132.     unsigned int highest_bit;
  133.     unsigned int cluster_next;
  134.     unsigned int cluster_nr;
  135.     int prio;            /* swap priority */
  136.     int pages;
  137.     unsigned long max;
  138.     unsigned long inuse_pages;
  139.     int next;            /* next entry on swap list */
  140. };
  141.  
  142. struct swap_list_t {
  143.     int head;    /* head of priority-ordered swapfile list */
  144.     int next;    /* swapfile to be used next */
  145. };
  146.  
  147. /* Swap 50% full? Release swapcache more aggressively.. */
  148. #define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
  149.  
  150. /* linux/mm/oom_kill.c */
  151. extern void out_of_memory(int gfp_mask);
  152.  
  153. /* linux/mm/memory.c */
  154. extern void swapin_readahead(swp_entry_t, unsigned long, struct vm_area_struct *);
  155.  
  156. /* linux/mm/page_alloc.c */
  157. extern unsigned long totalram_pages;
  158. extern unsigned long totalhigh_pages;
  159. extern long nr_swap_pages;
  160. extern unsigned int nr_free_pages(void);
  161. extern unsigned int nr_free_pages_pgdat(pg_data_t *pgdat);
  162. extern unsigned int nr_free_buffer_pages(void);
  163. extern unsigned int nr_free_pagecache_pages(void);
  164.  
  165. /* linux/mm/swap.c */
  166. extern void FASTCALL(lru_cache_add(struct page *));
  167. extern void FASTCALL(lru_cache_add_active(struct page *));
  168. extern void FASTCALL(activate_page(struct page *));
  169. extern void FASTCALL(mark_page_accessed(struct page *));
  170. extern void lru_add_drain(void);
  171. extern int rotate_reclaimable_page(struct page *page);
  172. extern void swap_setup(void);
  173.  
  174. /* linux/mm/vmscan.c */
  175. extern int try_to_free_pages(struct zone **, unsigned int, unsigned int);
  176. extern int shrink_all_memory(int);
  177. extern int vm_swappiness;
  178.  
  179. #ifdef CONFIG_MMU
  180. /* linux/mm/shmem.c */
  181. extern int shmem_unuse(swp_entry_t entry, struct page *page);
  182. #endif /* CONFIG_MMU */
  183.  
  184. extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
  185.  
  186. #ifdef CONFIG_SWAP
  187. /* linux/mm/page_io.c */
  188. extern int swap_readpage(struct file *, struct page *);
  189. extern int swap_writepage(struct page *page, struct writeback_control *wbc);
  190. extern int rw_swap_page_sync(int, swp_entry_t, struct page *);
  191.  
  192. /* linux/mm/swap_state.c */
  193. extern struct address_space swapper_space;
  194. #define total_swapcache_pages  swapper_space.nrpages
  195. extern void show_swap_cache_info(void);
  196. extern int add_to_swap(struct page *);
  197. extern void __delete_from_swap_cache(struct page *);
  198. extern void delete_from_swap_cache(struct page *);
  199. extern int move_to_swap_cache(struct page *, swp_entry_t);
  200. extern int move_from_swap_cache(struct page *, unsigned long,
  201.         struct address_space *);
  202. extern void free_page_and_swap_cache(struct page *);
  203. extern void free_pages_and_swap_cache(struct page **, int);
  204. extern struct page * lookup_swap_cache(swp_entry_t);
  205. extern struct page * read_swap_cache_async(swp_entry_t, struct vm_area_struct *vma,
  206.                        unsigned long addr);
  207. /* linux/mm/swapfile.c */
  208. extern long total_swap_pages;
  209. extern unsigned int nr_swapfiles;
  210. extern struct swap_info_struct swap_info[];
  211. extern void si_swapinfo(struct sysinfo *);
  212. extern swp_entry_t get_swap_page(void);
  213. extern int swap_duplicate(swp_entry_t);
  214. extern int valid_swaphandles(swp_entry_t, unsigned long *);
  215. extern void swap_free(swp_entry_t);
  216. extern void free_swap_and_cache(swp_entry_t);
  217. extern sector_t map_swap_page(struct swap_info_struct *, pgoff_t);
  218. extern struct swap_info_struct *get_swap_info_struct(unsigned);
  219. extern int can_share_swap_page(struct page *);
  220. extern int remove_exclusive_swap_page(struct page *);
  221. struct backing_dev_info;
  222.  
  223. extern struct swap_list_t swap_list;
  224. extern spinlock_t swaplock;
  225.  
  226. #define swap_list_lock()    spin_lock(&swaplock)
  227. #define swap_list_unlock()    spin_unlock(&swaplock)
  228. #define swap_device_lock(p)    spin_lock(&p->sdev_lock)
  229. #define swap_device_unlock(p)    spin_unlock(&p->sdev_lock)
  230.  
  231. /* linux/mm/thrash.c */
  232. extern struct mm_struct * swap_token_mm;
  233. extern unsigned long swap_token_default_timeout;
  234. extern void grab_swap_token(void);
  235. extern void __put_swap_token(struct mm_struct *);
  236.  
  237. static inline int has_swap_token(struct mm_struct *mm)
  238. {
  239.     return (mm == swap_token_mm);
  240. }
  241.  
  242. static inline void put_swap_token(struct mm_struct *mm)
  243. {
  244.     if (has_swap_token(mm))
  245.         __put_swap_token(mm);
  246. }
  247.  
  248. #else /* CONFIG_SWAP */
  249.  
  250. #define total_swap_pages            0
  251. #define total_swapcache_pages            0UL
  252.  
  253. #define si_swapinfo(val) \
  254.     do { (val)->freeswap = (val)->totalswap = 0; } while (0)
  255. #define free_page_and_swap_cache(page) \
  256.     page_cache_release(page)
  257. #define free_pages_and_swap_cache(pages, nr) \
  258.     release_pages((pages), (nr), 0);
  259.  
  260. #define show_swap_cache_info()            /*NOTHING*/
  261. #define free_swap_and_cache(swp)        /*NOTHING*/
  262. #define swap_duplicate(swp)            /*NOTHING*/
  263. #define swap_free(swp)                /*NOTHING*/
  264. #define read_swap_cache_async(swp,vma,addr)    NULL
  265. #define lookup_swap_cache(swp)            NULL
  266. #define valid_swaphandles(swp, off)        0
  267. #define can_share_swap_page(p)            0
  268. #define move_to_swap_cache(p, swp)        1
  269. #define move_from_swap_cache(p, i, m)        1
  270. #define __delete_from_swap_cache(p)        /*NOTHING*/
  271. #define delete_from_swap_cache(p)        /*NOTHING*/
  272. #define swap_token_default_timeout        0
  273.  
  274. static inline int remove_exclusive_swap_page(struct page *p)
  275. {
  276.     return 0;
  277. }
  278.  
  279. static inline swp_entry_t get_swap_page(void)
  280. {
  281.     swp_entry_t entry;
  282.     entry.val = 0;
  283.     return entry;
  284. }
  285.  
  286. /* linux/mm/thrash.c */
  287. #define put_swap_token(x) do { } while(0)
  288. #define grab_swap_token()  do { } while(0)
  289. #define has_swap_token(x) 0
  290.  
  291. #endif /* CONFIG_SWAP */
  292. #endif /* __KERNEL__*/
  293. #endif /* _LINUX_SWAP_H */
  294.